package com.fancy.common;

import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.Vector;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.fancy.common.utils.DateUtil;

/**
 * String处理的公共类.
 * 
 * @author xinfeng.hu 2013-3-13下午12:15:34
 * @version 1.0.0
 * @category 杭州广桥网络技术有限公司(商业先知)
 */
@SuppressWarnings({ "unused", "deprecation" })
public class StringUtil {

	/**
	 * 日志记录器
	 */
	private static final Logger logger = LoggerFactory.getLogger(StringUtil.class);

	/**
	 * 判断平台
	 * 
	 * @return
	 */
	public static DeviceTypeEnum getDeviceType(final String userAgent) {
		if (StringUtils.isNotBlank(userAgent)) {
			// 平台平台判断
			if (userAgent.indexOf("Mozilla") > -1) {
				return DeviceTypeEnum.WEB;
			} else if (userAgent.indexOf("iPhone") > -1) {
				return DeviceTypeEnum.IOS;
			} else if (userAgent.indexOf("iPad") > -1) {
				return DeviceTypeEnum.IOS;
			} else if (userAgent.indexOf("Android") > -1) {
				return DeviceTypeEnum.ANDROID;
			} else if (userAgent.indexOf("BB10") > -1) {
				return DeviceTypeEnum.BB10;
			}
			return DeviceTypeEnum.IOS;
		} else {
			logger.error("UserAgent[{}]", userAgent);
			return DeviceTypeEnum.UNKNOWN;
		}
	}
	
	public static String Rands(Integer num) {
		Random rd = new Random(); // 创建随机对象
		String n = ""; // 保存随机数
		int rdGet; // 取得随机数
		do {
			if (rd.nextInt() % 2 == 1) {
				rdGet = Math.abs(rd.nextInt()) % 10 + 48; // 产生48到57的随机数(0-9的键位值)
			} else {
				rdGet = Math.abs(rd.nextInt()) % 26 + 97; // 产生97到122的随机数(a-z的键位值)
			}
			char num1 = (char) rdGet; // int转换char
			String dd = Character.toString(num1);
			n += dd;
		} while (n.length() < num);// 设定长度，此处假定长度小于8

		return n.toUpperCase();
	}
	

	/**
	 * 返回去除前后空格的字符串。
	 * 
	 * @param str
	 *            字符串
	 * @return String 处理后的字符串
	 */
	public static String trim(String str) {
		if (str == null) {
			return null;
		}

		return str.trim();
	}

	/**
	 * 返回去除空格后的字符串,此空格包括字符串左边,中间,右边的空格,全角空格和半角空格
	 * 
	 * @param str
	 * @return String 处理后的字符串
	 */
	public static String trimLCR(String str) {
		StringBuffer sb = new StringBuffer();
		if (str != null && !str.equals("")) {
			for (int i = 0; i < str.length(); i++) {
				if (!(str.charAt(i) == ' ' || str.charAt(i) == '　')) {
					sb.append(str.charAt(i));
				}
			}
			return sb.toString();
		}
		return "";
	}

	public static String joinToStr(String[] willJoin, String linkStr) {
		if ((willJoin == null) || (willJoin.length == 0)) {
			return "";
		}

		int i;
		StringBuffer strJoined = new StringBuffer("");

		strJoined.append(willJoin[0]);

		for (i = 1; i < willJoin.length; i++) {
			strJoined.append(linkStr + willJoin[i]);
		}

		return strJoined.toString();
	}

	// 对于空格不连接
	public static String joinToStr1(String[] willJoin, String linkStr) {
		if ((willJoin == null) || (willJoin.length == 0)) {
			return "";
		}

		int i;
		StringBuffer strJoined = new StringBuffer("");

		boolean bflag = false; // 是否是第一个不为空的函数

		for (i = 0; i < willJoin.length; i++) {
			if (!StringUtil.isEmpty(willJoin[i])) {
				if (!bflag) {
					strJoined.append(willJoin[i]);
					bflag = true;
				} else {
					strJoined.append(linkStr + willJoin[i]);
				}
			}
		}

		return strJoined.toString();
	}

	public static boolean isGB(String orginStr) {
		char[] chars = orginStr.toCharArray();

		for (int i = 0; i < chars.length; i++) {
			if (chars[i] > 256) {
				return true;
			}
		}

		return false;
	}

	public static String joinToStr(int[] willJoin, String linkStr) {
		if ((willJoin == null) || (willJoin.length == 0)) {
			return "";
		}

		int i;
		StringBuffer strJoined = new StringBuffer("");

		strJoined.append(willJoin[0]);

		for (i = 1; i < willJoin.length; i++) {
			strJoined.append(linkStr + willJoin[i]);
		}

		return strJoined.toString();
	}

	/**
	 * 把字符串根据分隔符生成数组。
	 * 
	 * @param line
	 *            字符串
	 * @param delim
	 *            分隔符
	 * @return 字符串数组
	 */
	public static String[] splitEx(String line, String delim) {
		List<String> list = new ArrayList<String>();
		int i = 1;
		StringTokenizer t = new StringTokenizer(line, delim, true);

		while (t.hasMoreTokens()) {
			String s = t.nextToken(delim);

			if (delim.indexOf(s) >= 0) {
				i++;

				if (i > 1) {
					list.add("");
				}
			} else {
				i = 0;
				list.add(s);
			}
		}

		if (i > 0) {
			list.add("");
		}

		return (String[]) list.toArray(new String[list.size()]);
	}

	/**
	 * 把字符串根据分隔符生成字符串List,分隔号将被忽略，并且字符串将去前后空格（Sring.trim）。
	 * 
	 * @param line
	 *            字符串
	 * @param delim
	 *            分隔符
	 * @return 字符串数组
	 */
	public static List<String> splitExToList(String line, String delim) {
		List<String> list = new ArrayList<String>();
		StringTokenizer t = new StringTokenizer(line, delim, true);

		while (t.hasMoreTokens()) {
			String s = t.nextToken(delim);

			if (delim.indexOf(s) == 0) {
				continue;
			}
			if (0 != s.trim().length()) {
				list.add(s.trim());
			}

		}
		return list;
	}

	public static String[] split(String line, String delim) {
		List<String> list = new ArrayList<String>();
		StringTokenizer t = new StringTokenizer(line, delim);

		while (t.hasMoreTokens()) {
			list.add(t.nextToken());
		}

		return (String[]) list.toArray(new String[list.size()]);
	}

	/**
	 * 把字符串根据分隔符生成Integer数组。
	 * 
	 * @param array
	 *            字符串
	 * @return Integer[] 整型数组
	 */
	public static Integer[] toInteger(String[] array) {
		if (array == null)
			return null;

		Integer[] its = new Integer[array.length];
		for (int i = 0; i < array.length; i++) {
			its[i] = new Integer(array[i]);
		}

		return its;
	}

	/**
	 * 根据指定的分割符，分割数据
	 * 
	 * @param line
	 *            数据
	 * @param delim
	 *            分割符
	 * @return String[] 分割得到的数组
	 */
	public static String[] splitStr(String line, String delim) {
		if ((line == null) || (delim == null)) {
			return (new String[0]);
		}

		List<String> list = new ArrayList<String>();
		int startIndex = 0;
		int endIndex = 0;

		while ((endIndex = line.indexOf(delim, startIndex)) >= 0) {
			if (startIndex < endIndex) {
				list.add(line.substring(startIndex, endIndex));
			}

			startIndex = endIndex + delim.length();
		}

		if (startIndex < line.length()) {
			list.add(line.substring(startIndex));
		}

		return (String[]) list.toArray(new String[list.size()]);
	}

	/**
	 * 把字符串根据分隔符生成数组。
	 * 
	 * @param line
	 *            字符串
	 * @param delim
	 *            分隔符
	 * @return Vector 字符串向量
	 */
	public static Vector<String> split2v(String line, String delim) {
		Vector<String> list = new Vector<String>();
		StringTokenizer t = new StringTokenizer(line, delim);

		while (t.hasMoreTokens()) {
			list.add(t.nextToken());
		}

		return list;
	}

	/**
	 * 将一个字符串数组中的字符串根据一个连接符连成一个字符串。 字符串最后没有连接符。如果该数组只有一个元素，将只返回该元素。 如果连接符为null,
	 * 则以","默认进行连接。
	 * 
	 * @param saStr
	 *            要进行连接操作的字符串数组。
	 * @param sContacter
	 *            连接符。
	 * @return 连接完成后的字符串
	 */
	public static String contact(String[] saStr, String sContacter) {
		if ((saStr == null) || (saStr.length <= 0)) {
			return null;
		}

		if (sContacter == null) {
			sContacter = ",";
		}

		StringBuffer sRet = new StringBuffer();
		sRet.append(saStr[0]);

		for (int i = 1; i < saStr.length; i++) {
			if (saStr[i] != null) {
				sRet.append(sContacter + saStr[i]);
			}
		}

		return sRet.toString();
	}

	/**
	 * 将一个字符串数组中的字符串根据一个连接符连成一个字符串。 字符串最后没有连接符。如果该数组只有一个元素，将只返回该元素。 如果连接符为null,
	 * 则以","默认进行连接。
	 * 
	 * @param saStr
	 *            要进行连接操作的字符串数组。
	 * @param sContacter
	 *            连接符。
	 * @return 连接完成后的字符串
	 */
	// morgan新增 对于第一个元素为空的情况，不进行连接
	public static String contact1(String[] saStr, String sContacter) {
		if ((saStr == null) || (saStr.length <= 0)) {
			return null;
		}

		if (sContacter == null) {
			sContacter = ",";
		}

		StringBuffer sRet = new StringBuffer();

		for (int i = 0; i < saStr.length; i++) {
			if (saStr[i] != null) {
				sRet.append(sContacter);
			} else {
				sRet.append(sContacter).append(sContacter);
			}
		}

		return sRet.toString();
	}

	public static String contact(Set<String> set, String sContacter) {
		if (set.size() == 0)
			return null;
		StringBuffer sb = new StringBuffer();
		if (sContacter == null) {
			sContacter = ",";
		}

		Iterator<String> it = set.iterator();
		while (it.hasNext()) {
			String element = (String) it.next();
			sb.append(element + sContacter);
		}
		return sb.substring(0, sb.length() - sContacter.length());
	}

	/**
	 * 将一个字符串数组中的字符串根据一个连接符连成一个字符串。 字符串最后没有连接符。如果该数组只有一个元素，将只返回该元素。 如果连接符为null,
	 * 则以","默认进行连接。
	 * 
	 * @param saStr
	 *            要进行连接操作的字符串数组。
	 * @param sContacter
	 *            连接符。
	 * @return 连接完成后的字符串
	 */
	public static String contactEx(String[] saStr, String sContacter, String sInclude) {
		if ((saStr == null) || (saStr.length <= 0)) {
			return null;
		}

		if (sContacter == null) {
			sContacter = ",";
		}

		StringBuffer sRet = new StringBuffer();
		sRet.append(sInclude + saStr[0] + sInclude);

		for (int i = 1; i < saStr.length; i++) {
			if (saStr[i] != null) {
				sRet.append(sContacter + sInclude + saStr[i] + sInclude);
			}
		}

		return sRet.toString();
	}

	/**
	 * 将一个Integer数组中的字符串根据一个连接符连成一个字符串。 字符串最后没有连接符。如果该数组只有一个元素，将只返回该元素。
	 * 如果连接符为null, 则以","默认进行连接。
	 * 
	 * @param arr
	 *            要进行连接操作的Integer数组。
	 * @param sContacter
	 *            连接符。
	 * @return 连接完成后的字符串
	 */
	public static String contact(int[] arr, String sContacter) {
		if ((arr == null) || (arr.length <= 0)) {
			return null;
		}

		if (sContacter == null) {
			sContacter = ",";
		}

		StringBuffer sRet = new StringBuffer();
		sRet.append("" + arr[0]);

		for (int i = 1; i < arr.length; i++) {
			sRet.append(sContacter + arr[i]);
		}

		return sRet.toString();
	}

	/**
	 * 把Vector变量中的各个元素用一个连接字符串一一连接起来
	 * 
	 * @param willJoin
	 *            要连接的Vector类的变量
	 * @param linkStr
	 *            连接用的字符串
	 * @return String 经过连接的字符串
	 */
	public static String contact(Vector<?> willJoin, String linkStr) {
		if ((willJoin == null) || willJoin.isEmpty()) {
			return "";
		}

		int size = willJoin.size();
		StringBuffer strJoined = new StringBuffer();
		strJoined.append(willJoin.elementAt(0).toString());

		for (int i = 1; i < size; i++) {
			strJoined.append(linkStr + willJoin.elementAt(i).toString());
		}

		return strJoined.toString();
	}

	/**
	 * 把字符串中的部分字符用新的字符串替换。
	 * 
	 * @param line
	 *            原字符串
	 * @param oldString
	 *            被替换字符串
	 * @param newString
	 *            新字符串
	 * @return String 替换好的字符串
	 */
	public static final String replace(String line, String oldString, String newString) {
		if ((line == null) || (oldString == null) || (newString == null)) {
			return null;
		}

		int i = 0;

		if ((i = line.indexOf(oldString, i)) >= 0) {
			char[] line2 = line.toCharArray();
			char[] newString2 = newString.toCharArray();
			int oLength = oldString.length();
			StringBuffer buf = new StringBuffer(line2.length);
			buf.append(line2, 0, i).append(newString2);
			i += oLength;

			int j = i;

			while ((i = line.indexOf(oldString, i)) > 0) {
				buf.append(line2, j, i - j).append(newString2);
				i += oLength;
				j = i;
			}

			buf.append(line2, j, line2.length - j);

			return buf.toString();
		}

		return line;
	}

	/**
	 * 首字母大写其余都小写
	 * 
	 * @param data
	 *            要首字母大写的字符串。
	 * @return String 格式化后的数据
	 */
	public static String cap(String data) {
		String firstLetter = data.substring(0, 1).toUpperCase();
		String restLetters = data.substring(1).toLowerCase();

		return firstLetter + restLetters;
	}

	/**
	 * Returns true if the string represents a word, i.e. every char is either
	 * a-z, A-Z, 0-9, _.
	 * 
	 * @param str
	 *            数据
	 * @return boolean whether the string is a word
	 */
	public static boolean isWord(String str) {
		if (str == null) {
			return false;
		}

		byte[] asc = str.getBytes();

		for (int i = 0; i < asc.length; i++) {
			if (!isVisibleChar(asc[i])) {
				return false;
			}
		}

		return true;
	}

	/**
	 * 判断指定的字节是否是可以看到的字符
	 * 
	 * @param asc
	 *            字节
	 * @return boolean 是否是可以看到的字符
	 */
	public static boolean isVisibleChar(byte asc) {
		if (((asc >= 48) && (asc <= 57)) || ((asc >= 65) && (asc <= 90)) || ((asc >= 97) && (asc <= 122)) || (asc == 95) || (asc == 45)
				|| (asc == 46)) {
			return true;
		}

		return false;
	}

	/**
	 * 检验一个String是否数字, 如 .123, 123, -123, -.434, +430. 都是合法的数字.
	 * 
	 * @param str
	 *            要校验的字符串。
	 * @return boolean 如果是一个标准的实数，将返回true，否则返回false。
	 */
	public static boolean isNumberic(String str) {
		if (str == null) {
			return false;
		}

		str = str.trim();

		if (str.length() <= 0) {
			return false;
		}

		char[] ch = str.toCharArray();
		int count = 0;

		for (int i = 0; i < str.length(); i++) {
			if (!Character.isDigit(ch[i])) {
				if ((i == 0) && (ch[i] == '-' || ch[i] == '+')) {
					continue;
				}

				if ((ch[i] == '.') && ((++count) <= 1)) {
					continue;
				}

				return false;
			}
		}

		return true;
	}

	/**
	 * 检验一个String是否是金额, 如 1,200 , .123, 123, -123, -.434, +430. 都是合法的金额.
	 * 
	 * @param money
	 *            要校验的字符串。
	 * @return boolean 如果是一个标准的实数，将返回true，否则返回false。
	 */
	public static boolean isMoney(String money) {
		if (money == null || money.length() <= 0) {
			return false;
		}
		money = money.trim().replaceAll(",", "");

		boolean is = true;
		try {
			Double floatMoney = new Double(money);
		} catch (NumberFormatException e) {
			is = false;
		}

		return is;
	}

	/**
	 * 将标准的表示金额的字符串(例如"100,000,000.00")转化成double类型的数字，
	 * 
	 * @param money
	 *            要转化的金额字符串。
	 * @return Double 如果是一个标准的实数，将返回对应的金额，否则返回0。
	 */
	public static Double formatDouble(String money) {
		if (money == null || money.length() <= 0) {
			return new Double(0);
		}

		return new Double(money.trim().replaceAll(",", ""));
	}

	/**
	 * 检验一个String是否是合法的URL。
	 * 
	 * @param str
	 *            要校验的字符串。
	 * @return boolean 如果是合法URL，将返回true，否则返回false。
	 */
	public static boolean checkHomePageUrl(String str) {
		if (str == null) {
			return true;
		}

		if (str.length() == 0) {
			return true;
		}

		String s = str.toLowerCase();

		if (!s.startsWith("http://")) {
			return false;
		}

		if ((s.length() > 7) && (s.indexOf(".") == 7 || s.indexOf("http://", 1) > 1)) {
			return false;
		}

		return true;
	}

	/**
	 * 检验一个String是否是合法的邮件地址。
	 * 
	 * @param str
	 *            要校验的字符串。
	 * @return boolean 如果是合法的邮件地址，将返回true，否则返回false。
	 */
	public static boolean isEmail(String str) {
		if ((str == null) || (str.length() == 0))
			return false;

		str = str.trim();
		if (str.indexOf(' ') > 0)
			return false;
		int index = str.indexOf('@');
		if (index <= 0 || index == str.length() - 1 || index != str.lastIndexOf('@')) {
			return false;
		}
		if (str.indexOf('.') <= 0 || str.lastIndexOf('.') == str.length() - 1) {
			return false;
		} else if (str.lastIndexOf('.') < str.lastIndexOf('@')) {
			return false;
		}

		if (str.indexOf(".@") > 0 || str.indexOf("@.") > 0) {
			return false;
		}
		return true;
	}

	/**
	 * 判断指定数据是否为手机号码
	 * 
	 * @param str
	 *            数据
	 * @return boolean 是否为手机号码
	 */
	public static boolean isMobileNumber(String str) {
		if (StringUtil.isEmpty(str)) {
			return false;
		}

		if (str.length() != 11) {
			return false;
		}
		try {
			Long.parseLong(str);
		} catch (NumberFormatException e) {
			return false;
		}

		if (str.startsWith("13") || str.startsWith("15")) {
			return true;
		}

		return false;
	}

	/**
	 * 检验一个String符合一定长度，是否为空。
	 * 
	 * @param str
	 *            要校验的字符串。
	 * @param maxLen
	 *            最大字符串长度
	 * @param noAllowEmpty
	 *            是否允许为空
	 * @return boolean 如果是合法, 返回true，否则返回false。
	 */
	public static boolean isValidString(String str, int maxLen, boolean noAllowEmpty) {
		if (isExceed(str, maxLen)) {
			return false;
		}

		if (noAllowEmpty && isEmpty(str)) {
			return false;
		}

		return true;
	}

	/**
	 * 检验一个String字符是否太长。
	 * 
	 * @param str
	 *            要校验的字符串。
	 * @param maxLen
	 *            最大字符串长度
	 * @return boolean 如果是太长，将返回true，否则返回false。
	 */
	public static boolean isExceed(String str, int maxLen) {
		str = trim(str);

		if ((str != null) && (str.length() > maxLen)) {
			return true;
		}

		return false;
	}

	/**
	 * 检验一个String是否为空。
	 * 
	 * @param str
	 *            要校验的字符串。
	 * @return boolean 如果是空，将返回true，否则返回false。
	 */
	public static boolean isEmpty(String str) {
		if ((str == null) || (str.length() <= 0)) {
			return true;
		}
		return false;
	}

	/**
	 * 把code的值转换成路径 先把code取得hashCode码,再进行转化。
	 * 
	 * @param code
	 *            要转换的code
	 * @return String 表示路径的字符串
	 */
	public static String idToPath(String code) {
		return idToPath(Math.abs(code.hashCode()));
	}

	/**
	 * 把id的值转换成路径 例如: 89110 ==> 8/91/10/
	 * 
	 * @param newId
	 *            int 要转换的id
	 * @return String 表示路径的字符串
	 */
	public static String idToPath(long newId) {
		if (newId <= 0) {
			return "";
		}

		StringBuffer result = new StringBuffer("");

		while (newId > 0L) {
			result.insert(0, "" + (newId % 100L) + "/");
			newId /= 100L;
		}

		return result.toString();
	}

	/**
	 * Format Date into which format you define
	 * 
	 * @param date
	 *            (java.util.Date)
	 * @param newFormat
	 *            (String)
	 * @return String example formatDate(date, "MMMM dd, yyyy") = July 20, 2000
	 */
	public static String formatDate(Date date, String newFormat) {
		if ((date == null) || (newFormat == null)) {
			return null;
		}

		java.text.SimpleDateFormat formatter = new java.text.SimpleDateFormat(newFormat);

		return formatter.format(date);
	}

	/**
	 * 以[yyyy-MM-dd]格式化时间
	 * 
	 * @param theDate
	 *            要格式化的时间
	 * @return String 格式化后的时间
	 */
	public static String formatDate(Date theDate) {
		return formatDate(theDate, "yyyy-MM-dd");
	}

	/**
	 * 生成sql用的时间字段
	 * 
	 * @param theDate
	 *            时间
	 * @return String sql用的时间字段
	 */
	public static String getSqlDate(Date theDate) {
		StringBuffer sb = new StringBuffer();
		sb.append("TO_DATE('");
		sb.append(formatDate(theDate));
		sb.append("', 'yyyy-mm-dd hh24:mi:ss..')");

		return sb.toString();
	}

	/**
	 * Make sure a string is not null.
	 * 
	 * @param theString
	 *            Any string, possibly null
	 * @return String An empty string if the original was null, else the
	 *         original
	 */
	public static String notNull(String theString) {
		if (theString == null) {
			return new String("");
		}

		return theString;
	}

	/**
	 * 判断在数组中是否有指定的字符串
	 * 
	 * @param strArray
	 *            字符串数组
	 * @param str
	 *            字符串
	 * @return boolean 是否存在
	 */
	public static boolean strExistsInArray(String[] strArray, String str) {
		if (str == null) {
			return false;
		}

		for (int i = 0; i < strArray.length; i++)
			if (strArray[i].equals(str)) {
				return true;
			}

		return false;
	}

	/**
	 * 替换换行和空格成为html的换行和空格
	 * 
	 * @param newStr
	 *            要替换的字符串
	 * @return String 替换的结果字符串
	 */
	public static String getHtmlString(String newStr) {
		if (newStr == null) {
			return "";
		}

		String s = StringUtil.replace(newStr, "  ", " &nbsp;");
		s = StringUtil.replace(s, "\n", "<br>");

		return s;
	}

	/**
	 * 按照英文习惯使字符串自动分行功能, 即找指定长度后的第一个空格进行换行
	 * 
	 * @param sOld
	 *            传入的字符串
	 * @param iNum
	 *            大概多少字符串为一行
	 * @return String 转化后的字符串
	 */
	public static String wrapEnStr(String sOld, int iNum) {
		if ((sOld == null) || (sOld.length() < iNum)) {
			return sOld;
		}

		String sSplitter = "\n";
		int iEnd = 0;
		int iLen = 0;
		int iStart = 0;
		boolean bTrue = true;
		int j = 0;
		StringBuffer sbTemp = new StringBuffer();
		StringBuffer sbRtn = new StringBuffer();
		String[] sNew = splitStr(sOld, sSplitter);

		for (int i = 0; i < sNew.length; i++) {
			iLen = sNew[i].length();

			if (iLen <= iNum) {
				sbRtn.append(sNew[i]);

				continue;
			}

			j = 0;
			sbTemp.delete(0, sbTemp.length());

			while (bTrue) {
				iEnd = sNew[i].indexOf(" ", (j + 1) * iNum);

				if (iEnd > 0) {
					sbTemp.append(sNew[i].substring(iStart, iEnd)).append("\n");
					iStart = iEnd + 1;
					j++;
				} else {
					sbTemp.append(sNew[i].substring(iStart, iLen)).append("\n");
					iStart = 0;
					bTrue = false;
				}
			}

			bTrue = true;
			sbRtn.append(sbTemp.toString());
		}

		return sbRtn.toString();
	}

	/**
	 * 把字符串中的特殊字符转化成“_”，用正则表达式
	 * 
	 * @param name
	 *            Description of the Parameter
	 * @return String Description of the Return Value
	 */

	public static String encodeURL(String name) {
		try {
			name = java.net.URLEncoder.encode(name, "US-ASCII");
		} catch (Exception e) {
		}
		return name;
	}

	/**
	 * encodeurl，使用Utf8编码
	 * 
	 * @param name
	 *            要编码的字符
	 * @return String 编码后的字符
	 */
	public static String encodeUrlByUtf8(String name) {
		if (name == null) {
			return "";
		}
		try {
			name = java.net.URLEncoder.encode(name, "UTF-8");
		} catch (Exception e) {
		}
		return name;
	}

	/**
	 * 转化日志的编码
	 * 
	 * @param logInfo
	 *            日志信息
	 * @return String 转化编码后的日志信息
	 */
	public static String transLog(String logInfo) {
		return StringUtil.transChiTo8859(logInfo);
	}

	/**
	 * 从头部或者尾部，截取指定长度的字符串
	 * 
	 * @param str
	 *            数据
	 * @param maxLen
	 *            截取长度
	 * @param truncHead
	 *            是否从头部截取
	 * @return String 截取的字符串
	 */
	public static String truncStr(String str, int maxLen, boolean truncHead) {
		if (StringUtil.isEmpty(str)) {
			return "";
		}
		int len = str.length();
		if (len > maxLen) {
			if (truncHead) {
				return str.substring(len - maxLen);
			} else {
				return str.substring(0, maxLen);
			}
		} else {
			return str;
		}
	}

	/**
	 * 取得指定字节数的数据，后面补...
	 * 
	 * @param str
	 *            字符串
	 * @param len
	 *            截取长度
	 * @return String 截取的字符串
	 */
	public static String substring(String str, int len) {
		if (StringUtil.isEmpty(str) || (str.length() <= len)) {
			return str;
		}

		if (len <= 0) {
			return "";
		}

		String sub = str.substring(0, len);
		byte[] b = sub.getBytes();
		int count = 0;

		for (int index = 0; index < b.length; index++) {
			if (b[index] < 0) {
				count++;
			}
		}

		if ((count % 2) != 0) {
			sub = sub.substring(0, sub.length() - 1);
		}

		return sub + "...";
	}

	/**
	 * 深成一个随机的密码
	 * 
	 * @return String 随机密码
	 */
	public static String genPasswd() {
		java.util.Date date = new Date();
		String[] select = new String[63];
		select[1] = "A";
		select[2] = "B";
		select[3] = "C";
		select[4] = "D";
		select[5] = "E";
		select[6] = "F";
		select[7] = "G";
		select[8] = "H";
		select[9] = "I";
		select[10] = "J";
		select[11] = "K";
		select[12] = "L";
		select[13] = "M";
		select[14] = "N";
		select[15] = "O";
		select[16] = "P";
		select[17] = "Q";
		select[18] = "R";
		select[19] = "S";
		select[20] = "T";
		select[21] = "U";
		select[22] = "V";
		select[23] = "W";
		select[24] = "X";
		select[25] = "Y";
		select[26] = "Z";
		select[27] = "0";
		select[28] = "1";
		select[29] = "2";
		select[30] = "3";
		select[31] = "4";
		select[32] = "5";
		select[33] = "6";
		select[34] = "7";
		select[35] = "8";
		select[36] = "9";
		select[37] = "a";
		select[38] = "b";
		select[39] = "c";
		select[40] = "d";
		select[41] = "e";
		select[42] = "f";
		select[43] = "g";
		select[44] = "h";
		select[45] = "i";
		select[46] = "j";
		select[47] = "k";
		select[48] = "l";
		select[49] = "m";
		select[50] = "n";
		select[51] = "o";
		select[52] = "p";
		select[53] = "q";
		select[54] = "r";
		select[55] = "s";
		select[56] = "t";
		select[57] = "u";
		select[58] = "v";
		select[59] = "w";
		select[60] = "x";
		select[61] = "y";
		select[62] = "z";
		java.lang.StringBuffer nbuf = new java.lang.StringBuffer();
		java.util.Random rnum = new java.util.Random(date.getTime());
		int i = 0, j = 0;
		double d = 0;
		// System.out.println("Generating password...");
		do {
			{
				int rands = -1;
				d = rnum.nextDouble();
				rands = new Double(d * 62).intValue();
				j = rands + 1;
			}
			nbuf.append(select[j]);
			i++;
		} while (i < 8); // change this for size of password
		return nbuf.toString();
	}

	// /**
	// * 邮件编码
	// * @param src 数据
	// * @return String 编码之后的数据
	// */
	// public static String mailEncode(String src) {
	// String rtnval = "";
	// sun.misc.BASE64Encoder enc = new sun.misc.BASE64Encoder();
	// rtnval = " =?GB2312?B?" + enc.encode(src.getBytes()) + "?= ";
	// rtnval = StringUtil.replace(rtnval, "\n", "");
	// return rtnval;
	// }

	/**
	 * Queryify the string, disable the single quota in the string. Creation
	 * date: (5/15/00 10:29:13 AM)
	 * 
	 * @param str
	 *            要编辑的数据
	 * @return String 转化了单引号之后的记录
	 */
	public static String querify(String str) {
		String stRet = "";

		try {
			for (int i = 0; i < str.length(); i++) {
				stRet = stRet + str.charAt(i);

				if (str.charAt(i) == '\'') {
					stRet += '\'';
				}
			}

			return stRet;
		} catch (Exception e) {
			System.err.println(e);

			return null;
		}
	}

	/**
	 * 把ID转化成路径，每两个数字转化成为一个文件夹
	 * 
	 * @param newId
	 *            ID
	 * @return String 文件路径
	 */
	public static String idToPath(int newId) {

		if (newId <= 0) {

			return "";

		}

		String tmpId = "" + newId;

		String id;

		int bypassLength = 0;

		int strLength = tmpId.length();

		StringBuffer resault = new StringBuffer("");

		if (tmpId.endsWith("0")) {

			bypassLength++;

		}// bypass one if the temId is end with '0'. Sample: 89000 -> 8900

		if ((strLength % 2 - bypassLength) == 0) {

			bypassLength += 2;

		} // bypass two if length is . Sample: 890834 -> 8908, 89000 -> 89

		else {

			bypassLength++;

		}// bypass one

		for (int i = 0; i < strLength - bypassLength; i += 2) {

			resault.append(tmpId.substring(i, i + 2) + '/');

		}

		return resault.toString();

	}

	/**
	 * 从左边开始截取指定长度的字符串
	 * 
	 * @param str
	 *            元字符串
	 * @param length
	 *            截取长度
	 * @return String 截取的字符串
	 */
	public static String left(String str, int length) {
		return StringUtils.left(str, length);
	}

	/**
	 * 根据开始位置和截取长度截取字符串
	 * 
	 * @param str
	 *            字符串
	 * @param start
	 *            开始位置
	 * @param length
	 *            截取长度
	 * @return String 截取的字符串
	 */
	public static String mid(String str, int start, int length) {
		return StringUtils.mid(str, start, length);
	}

	/**
	 * 整数数组转化成为[整数,整数,整数]的格式的字符串
	 * 
	 * @param intArr
	 *            整数数组
	 * @param sContacter
	 * @return String 字符串
	 */
	public static String contactStrsToQueryString(int[] intArr, String sContacter) {
		if ((intArr == null) || (intArr.length <= 0) || (sContacter == null) || (sContacter.length() <= 0)) {
			return null;
		}

		String retStr = intArr[0] + "";
		for (int i = 1; i < intArr.length; i++) {
			retStr += "," + intArr[i] + "";
		}

		return retStr;

	}

	/**
	 * 字符串转码[Iso2Gbk]
	 * 
	 * @param str
	 *            元字符串
	 * @return String 转码后的字符串
	 */
	public static String getIso2GbkCode(String str) {
		if (isEmpty(str)) {
			return str;
		} else {
			try {
				return new String(str.getBytes("ISO-8859-1"), "GBK");
			} catch (UnsupportedEncodingException ue) {
				return str;
			}
		}
	}

	/**
	 * 字符串转码[UTF82Gbk]
	 * 
	 * @param str
	 *            元字符串
	 * @return String 转码后的字符串
	 */
	public static String getUTF82GbkCode(String str) {
		if (isEmpty(str)) {
			return str;
		} else {
			try {
				return new String(str.getBytes("utf-8"), "GBK");
			} catch (UnsupportedEncodingException ue) {
				return str;
			}
		}
	}

	/**
	 * 字符串转码[Gbk2Iso]
	 * 
	 * @param str
	 *            元字符串
	 * @return String 转码后的字符串
	 */
	public static String getGbk2IsoCode(String str) {
		if (isEmpty(str)) {
			return null;
		} else {
			try {
				return new String(str.getBytes("GBK"), "ISO-8859-1");
			} catch (UnsupportedEncodingException ue) {
				return str;
			}
		}
	}

	/**
	 * 字符串转码[Gbk2UTF8]
	 * 
	 * @param str
	 *            元字符串
	 * @return String 转码后的字符串
	 */
	public static String getGbk2UTF8Code(String str) {
		if (isEmpty(str)) {
			return null;
		} else {
			try {
				return new String(str.getBytes("GBK"), "utf-8");
			} catch (UnsupportedEncodingException ue) {
				return str;
			}
		}
	}

	/**
	 * 根据ID生成文件路径
	 * 
	 * @param newId
	 *            文件ID
	 * @return String 文件路径 [9900 -> 99/00/ 99000 -> 09/90/00]
	 */
	public static String sampleIdToPath(int newId) {
		if (newId <= 0) {
			return "";
		}

		String tmpId = "" + newId;
		String id;
		int bypassLength = 0;
		int strLength = tmpId.length();
		StringBuffer resault = new StringBuffer("");

		if (tmpId.endsWith("0")) {
			bypassLength++;
		}

		// bypass one if the temId is end with '0'. Sample: 89000 -> 8900
		if (((strLength % 2) - bypassLength) == 0) {
			bypassLength += 2;
		} // bypass two if length is . Sample: 890834 -> 8908, 89000 -> 89
		else {
			bypassLength++;
		}

		// bypass one
		for (int i = 0; i < (strLength - bypassLength); i += 2) {
			resault.append(tmpId.substring(i, i + 2) + '/');
		}

		return resault.toString();
	}

	/**
	 * 把字符串格式化为[YYYY-MM-DD]
	 * 
	 * @param strDate
	 *            时间
	 * @return Date 时间
	 */
	public static java.util.Date getDate(String strDate) {
		String strYear = strDate.substring(0, strDate.indexOf("-"));
		String s1 = strDate.substring(strDate.indexOf("-") + 1);
		String strMonth = s1.substring(0, s1.indexOf("-"));
		String strDay = s1.substring(s1.indexOf("-") + 1);
		return new java.util.Date(new Integer(strYear).intValue() - 1900, new Integer(strMonth).intValue() - 1, new Integer(strDay).intValue());
	}

	/**
	 * 把日期时间类型转换为YYYY-MM-DD格式的字符串
	 * 
	 * @param dt
	 *            时间
	 * @return String [YYYY-MM-DD]格式的时间
	 */
	public static String getDate(java.util.Date dt) {
		String strMonth = "00" + (dt.getMonth() + 1);
		strMonth = strMonth.substring(strMonth.length() - 2);
		String strDay = "00" + (dt.getDate());
		strDay = strDay.substring(strDay.length() - 2);
		return "" + (dt.getYear() + 1900) + "-" + strMonth + "-" + strDay;

	}

	/**
	 * 取得日期格式[yyyy-MM-dd HH:mm:ss]，其中时间[HH:mm:ss]为0
	 * 
	 * @param days
	 *            如果是正数，则返回当天+days天，反之返回当前-days天
	 * @return
	 */
	public static String getDate(int days) {
		Date date = DateUtil.addDateDay(new Date(), days);
		return StringUtil.formatDate(date, "yyyy-MM-dd HH:mm:ss").substring(0, 11).concat("00:00:00");
	}

	/**
	 * 取得当前小时
	 * 
	 * @param hours
	 *            hours 如果是正数，则返回当天+hours天，反之返回当前-hours天
	 * @return
	 */
	public static String getHour(int hours) {
		Calendar calendar = Calendar.getInstance();
		SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:00:00");
		calendar.add(Calendar.HOUR_OF_DAY, hours);
		return format.format(calendar.getTime());
	}

	/**
	 * 把日期时间类型转换为 HH:MM:SS格式的字符串
	 * 
	 * @param dt
	 *            时间
	 * @return String [HH:MM:SS]格式的时间
	 */
	public static String getTime(java.util.Date dt) {
		String strHour = "00" + dt.getHours();
		strHour = strHour.substring(strHour.length() - 2);
		String strMinutes = "00" + dt.getMinutes();
		strMinutes = strMinutes.substring(strMinutes.length() - 2);
		String strSeconds = "00" + dt.getSeconds();
		strSeconds = strSeconds.substring(strSeconds.length() - 2);
		return strHour + ":" + strMinutes + ":" + strSeconds;

	}

	/**
	 * 根据给定的日期得到特殊日期
	 * 
	 * @param adt_days
	 *            根据的日期
	 * @param ai_flag
	 *            转换类型 2、后一天 3、月初 4、月末 5、年初 6、年末 7、季度初 8、季度末 9、去年同天 10 、周一 11
	 *            、周末 12、上月初 13、下月初 14、明年同一天
	 * @return Date 结果日期
	 */
	public static Date getSpecDays(Date adt_days, int ai_flag) {

		GregorianCalendar gcalendar = new GregorianCalendar();
		Date dtTemp = null;
		int nYear = adt_days.getYear();
		int nMonth = adt_days.getMonth();
		int nDay = adt_days.getDate();
		int nWeek = adt_days.getDay();

		switch (ai_flag) {
		case 1:// 前一天
			if (nDay > 1) {
				dtTemp = new Date(nYear, nMonth, nDay - 1);
			} else {
				dtTemp = getSpecDays(adt_days, 12);
				dtTemp = getSpecDays(dtTemp, 4);
			}
			break;
		case 2:// 后一天
			if (getSpecDays(adt_days, 4).getDate() == nDay)
				dtTemp = getSpecDays(adt_days, 13);
			else
				dtTemp = new Date(nYear, nMonth, nDay + 1);
			break;
		case 3:// 月初
			dtTemp = new Date(nYear, nMonth, 1);
			break;
		case 4:// 月末
			switch (nMonth) {
			case 1:
				if (gcalendar.isLeapYear(nYear + 1900))
					nDay = 29;
				else
					nDay = 28;
				break;
			case 3:
				nDay = 30;
				break;
			case 5:
				nDay = 30;
				break;
			case 8:
				nDay = 30;
				break;
			case 10:
				nDay = 30;
				break;
			default:
				nDay = 31;
				break;
			}
			dtTemp = new Date(nYear, nMonth, nDay);
			break;
		case 5:// 年初
			dtTemp = new Date(nYear, 1, 1);
			break;
		case 6:// 年末
			dtTemp = new Date(nYear, 12, 31);
			break;
		case 7:// 季度初
			nMonth = (int) (nMonth / 3) * 3;
			dtTemp = new Date(nYear, nMonth, 1);
			break;
		case 8:// 季度末
			nMonth = (int) (nMonth / 3) * 3 + 2;
			dtTemp = getSpecDays(new Date(nYear, nMonth, 1), 4);
			break;
		case 9:// 去年同一天
			if (nMonth == 1 && nDay == 29)
				dtTemp = new Date(nYear - 1, nMonth, 28);
			else
				dtTemp = new Date(nYear - 1, nMonth, nDay);
			break;
		case 10:// 周一
			dtTemp = adt_days;
			if (nWeek == 0)
				nWeek = 7;
			for (int i = 1; i < nWeek; i++) {
				dtTemp = getSpecDays(dtTemp, 1);
			}
			break;
		case 11:// 周末(周日）
			dtTemp = adt_days;
			if (nWeek == 0)
				nWeek = 7;
			for (int i = nWeek; i < 7; i++) {
				dtTemp = getSpecDays(dtTemp, 2);
			}
			break;
		case 12:// 上月初
			if (nMonth == 0) {
				nMonth = 11;
				nYear--;
			} else {
				nMonth = nMonth - 1;
			}
			dtTemp = new Date(nYear, nMonth, 1);
			break;
		case 13:// 下月初
			if (nMonth == 11) {
				nMonth = 0;
				nYear++;
			} else {
				nMonth = nMonth + 1;
			}
			dtTemp = new Date(nYear, nMonth, 1);
			break;
		case 14:// 明年同一天
			if (nMonth == 1 && nDay == 29)
				dtTemp = new Date(nYear + 1, nMonth, 28);
			else
				dtTemp = new Date(nYear + 1, nMonth, nDay);
			break;
		}
		return dtTemp;

	}

	/**
	 * 某日期之后任意天之后的日期(如果是负数则是之前）
	 * 
	 * @param adt_days
	 *            日期
	 * @param nDays
	 *            间隔天数
	 * @return Date 日期之后任意天之后的日期
	 */
	public static Date getABDays(Date adt_days, int nDays) {
		Date dtTemp;
		dtTemp = adt_days;
		if (nDays > 0)
			for (int i = 0; i < nDays; i++)
				dtTemp = getSpecDays(dtTemp, 2);
		else if (nDays < 0) {
			nDays = 0 - nDays;
			for (int i = 0; i < nDays; i++)
				dtTemp = getSpecDays(dtTemp, 1);
		}
		return dtTemp;
	}

	/**
	 * 把日期时间类型转换为YYYY-MM格式的字符串
	 * 
	 * @param dt
	 *            时间
	 * @return String 格式化后的字符串[YYYY-MM]
	 */
	public static String getYearmonth(java.util.Date dt) {
		String strYearmonth = getDate(dt);
		return strYearmonth.substring(0, 4) + "-" + strYearmonth.substring(5, 7);

	}

	/**
	 * 计算两个字符型日期(YYYY-MM)之间的月份差
	 * 
	 * @param strDate1
	 *            月份A
	 * @param strDate2
	 *            月份B
	 * @return int 两个字符型日期(YYYY-MM)之间的月份差
	 */
	public static int getIntervalMonth(String strDate1, String strDate2) {
		return (Integer.parseInt(strDate1.substring(0, 4)) - Integer.parseInt(strDate2.substring(0, 4))) * 12
				+ Integer.parseInt(strDate1.substring(5, 7)) - Integer.parseInt(strDate2.substring(5, 7));
	}

	/**
	 * 计算字符型(YYYY-MM)后或者之前的月份2003-01后1个月为2003-02
	 * 
	 * @param strMonth
	 *            月份[YYYY-MM]
	 * @param nMonths
	 *            间隔月份
	 * @return String nMonths月之后的时间
	 */
	public static String getABMonths(String strMonth, int nMonths) {
		Date dtTemp;
		dtTemp = getDate(strMonth.substring(0, 4) + "-" + strMonth.substring(4, 6) + "-01");
		if (nMonths >= 0)
			for (int i = 1; i < nMonths; i++)
				dtTemp = getSpecDays(dtTemp, 13);
		else if (nMonths <= 0) {
			nMonths = 0 - nMonths;
			for (int i = 1; i < nMonths; i++)
				dtTemp = getSpecDays(dtTemp, 12);
		}
		return getYearmonth(dtTemp);

	}

	/**
	 * 判断日期是否合法
	 * 
	 * @param hizuke
	 *            日期
	 * @return boolean 日期是否合法
	 */
	public boolean isDate(String hizuke) {
		final int D_SIZE = 10;
		final int SL_PT1 = 4;
		final int SL_PT2 = 7; //
		StringBuffer strBuff;
		String str;
		int yy;
		int mm;
		int dd;
		Calendar cal;
		Date date;

		if (hizuke.length() != D_SIZE) {
			return (false);
		} //

		if ((SL_PT1 != hizuke.indexOf('/')) || (SL_PT2 != hizuke.lastIndexOf('/'))) {
			return (false);
		} //

		strBuff = new StringBuffer(hizuke);
		strBuff.deleteCharAt(4);
		strBuff.deleteCharAt(6);
		str = strBuff.substring(0);
		if (!isNum(str)) {
			return (false);
		}
		yy = Integer.parseInt(str.substring(0, 4));
		mm = Integer.parseInt(str.substring(4, 6));
		dd = Integer.parseInt(str.substring(6, 8)); //
		cal = new GregorianCalendar();
		cal.setLenient(false);
		cal.set(yy, mm - 1, dd);
		try {
			date = cal.getTime();
		} catch (Exception err) {
			return (false);
		} //
		return (true);

	}

	/**
	 * 判断是否是数字
	 * 
	 * @param num
	 *            字符串数据
	 * @return boolean 该字符串是否为数字
	 */
	public static boolean isNum(String num) {
		long lnum;
		int inum;
		float fnum;

		try {
			lnum = Long.parseLong(num);
			return (true);
		} catch (Exception ex) {

			try {
				fnum = Float.parseFloat(num);
				return (true);
			} catch (Exception ex1) {

				try {
					inum = Integer.parseInt(num);
					return (true);
				} catch (Exception ex2) {

					return (false);
				}
			}
		}
	}

	/**
	 * 判断是不是一个有效的电话
	 * 
	 * @param phone
	 *            电话
	 * @param minLength
	 *            最小长度
	 * @param maxLength
	 *            最大长度
	 * @param dash
	 *            dash
	 * @param delim
	 *            分割符
	 * @return boolean 是不是一个有效的电话
	 */
	public static boolean isValidPhoneNumber(String phone, int minLength, int maxLength, String dash, String delim) {
		if (StringUtil.isEmpty(phone)) {
			return false;
		}
		java.util.regex.Pattern pattern = java.util.regex.Pattern.compile("[0-9" + dash + "]*");
		Matcher matcher = pattern.matcher(phone);
		if (matcher.matches()) {
			String[] phoneArr = phone.split(delim);
			if (phoneArr.length < minLength || phoneArr.length > maxLength) {
				return false;
			}
			return true;
		} else {
			return false;
		}
	}

	/**
	 * 构造贸易通电话4部分
	 * 
	 * @param part1
	 *            part1
	 * @param part2
	 *            part2
	 * @param part3
	 *            part3
	 * @param part4
	 *            part4
	 * @param dash
	 *            dash
	 * @return String 贸易通电话
	 */
	public static String concatContactPhoneNumber(String part1, String part2, String part3, String part4, String dash) {
		StringBuffer returnPhone = new StringBuffer(dash);

		returnPhone.append(isEmpty(part1) ? " " + dash : part1 + dash);
		returnPhone.append(isEmpty(part2) ? " " + dash : part2 + dash);
		returnPhone.append(isEmpty(part3) ? " " + dash : part3 + dash);
		returnPhone.append(isEmpty(part4) ? " " + dash : part4 + dash);
		return returnPhone.toString();
	}

	/**
	 * 构造贸易通电话3部分
	 * 
	 * @param part1
	 *            part1
	 * @param part2
	 *            part2
	 * @param part3
	 *            part3
	 * @param dash
	 *            dash
	 * @return String 贸易通电话
	 */
	public static String concatContactPhoneNumber(String part1, String part2, String part3, String dash) {
		StringBuffer returnPhone = new StringBuffer(dash);

		returnPhone.append(isEmpty(part1) ? " " + dash : part1 + dash);
		returnPhone.append(isEmpty(part2) ? " " + dash : part2 + dash);
		returnPhone.append(isEmpty(part3) ? " " + dash : part3 + dash);
		return returnPhone.toString();

	}

	/**
	 * 解析贸易通电话
	 * 
	 * @param phoneNo
	 *            贸易通电话
	 * @param len
	 *            长度
	 * @param delim
	 *            分割符
	 * @return String[] 分割后的数据
	 */
	public static String[] splitContactPhoneNumber(String phoneNo, int len, String delim) {
		// len = 4 有分机 如果是#***# # # #
		int mainArea = 2;
		String[] phone = new String[len];// 最后返回的数据
		for (int i = 0; i < len; i++) {
			phone[i] = "";
		}
		if (StringUtil.isEmpty(phoneNo)) {
			return phone;
		}
		String[] part = split(phoneNo, delim);

		if (part.length < len) {
			phone[mainArea] = phoneNo.trim();
		} else if (part.length == len) {
			for (int i = 0; i < len; i++) {
				phone[i] = part[i].trim();
			}
		} else if (part.length > len) {
			// 如果大于预计长度,
			// len = 3 则将截取前两部分之后的部分默认给第三部分
			// len = 4 截取前两部分,再截去最后一部分,中间部分默认给第三部分
			phone[0] = part[0].trim();
			phone[1] = part[1].trim();
			StringBuffer sb = new StringBuffer();
			for (int i = 2; i < part.length - 1; i++) {
				sb.append(part[i]).append("#");
			}
			String sbStr = sb.toString();
			phone[mainArea] = sbStr.substring(0, sbStr.length() - 1).trim();
			if (len == 4) {
				phone[3] = part[part.length - 1].trim();
			}
		}
		// 如果仅仅有国家代码则置空
		boolean bNullFlag = false;
		for (int i = 1; i < phone.length; i++) {
			if (!isEmpty(phone[i].trim())) {
				bNullFlag = true;
				break;
			}
		}
		if (!bNullFlag) {
			phone[0] = "";
		}

		return phone;
	}

	/**
	 * 按字节截取字符串,中文当两个字节。
	 * 
	 * @param str
	 *            字符串
	 * @param len
	 *            截取长度
	 * @return String 截取的字符串
	 */
	public static String substrWithByte(String str, int len) {
		return StringUtil.substring(str, len, "...");
	}

	/**
	 * 转换字符串(html代码串)中的特殊字符
	 * 
	 * @param Str
	 *            --需要转换的字符串
	 * @return String --返回把特殊字符转换了的字符串
	 */
	public static String escapeHtml(String Str) {
		if (Str == null)
			return "";
		char[] data = Str.toCharArray();
		int len = data.length;
		StringBuffer result = new StringBuffer(len * 2);

		int begin = 0, count = 0, tt = 0;
		for (int i = 0; i < len; i++) {
			switch (data[i]) {
			case '&':
				result.append(new String(data, begin, count));
				result.append("&amp;");
				begin = i + 1;
				count = 0;
				break;
			case '\"':
				result.append(new String(data, begin, count));
				result.append("&quot;");
				begin = i + 1;
				count = 0;
				break;
			case '\'':
				result.append(new String(data, begin, count));
				result.append("&#039;");
				begin = i + 1;
				count = 0;
				break;
			case '<':
				result.append(new String(data, begin, count));
				result.append("&lt;");
				begin = i + 1;
				count = 0;
				break;
			case '>':
				result.append(new String(data, begin, count));
				result.append("&gt;");
				begin = i + 1;
				count = 0;
				break;
			default:
				count++;
				break;
			}
		}
		if (count > 0)
			result.append(new String(data, begin, count));
		return result.toString();
	}

	/**
	 * 乘法运算
	 * 
	 * @param a
	 *            乘数
	 * @param b
	 *            被乘数
	 * @return double 结果
	 */
	public static double pageMultiply(double a, double b) {
		return a * b;
	}

	/**
	 * 加法运算
	 * 
	 * @param a
	 *            数字a
	 * @param b
	 *            数字b
	 * @return double 加法结果
	 */
	public static double pageAdd(double a, double b) {
		return a + b;
	}

	/**
	 * 两个数相减
	 * 
	 * @param a
	 *            数a
	 * @param b
	 *            数b
	 * @return double 相减的结果
	 */
	public static double pageMinus(double a, double b) {
		return a - b;
	}

	/**
	 * 格式化浮点数数据
	 * 
	 * @param decimal
	 *            浮点数数据
	 * @param pattern
	 *            格式
	 * @return String 格式化后的数据
	 */
	public String formatDecimal(double decimal, String pattern) {
		DecimalFormat df = new DecimalFormat();
		if (StringUtil.isEmpty(pattern)) {
			df.applyPattern("#,###.##");
		} else {
			df.applyPattern(pattern);
		}
		return df.format(decimal);

	}

	/**
	 * 浮点数数据格式化成为字符串
	 * 
	 * @param decimal
	 *            浮点数
	 * @return String 格式化后的数据[#,###.##]
	 */
	public String formatDecimal(double decimal) {
		return formatDecimal(decimal, "");
	}

	/**
	 * 判断指定的数据是否为0 ，如果小于0.000000001也当作0来使用
	 * 
	 * @param decimal
	 *            数据
	 * @return boolean 是否为0
	 */
	public boolean isZero(double decimal) {

		if (decimal - 0.00 < 0.000000001) {
			return true;
		}
		return false;
	}

	/**
	 * 取字符串的前toCount个字符
	 * 
	 * @param str
	 *            被处理字符串
	 * @param toCount
	 *            截取长度
	 * @param more
	 *            后缀字符串
	 * @return String
	 */
	public static String substring(String str, int toCount, String more) {
		int reInt = 0;
		String reStr = "";
		if (str == null)
			return "";
		char[] tempChar = str.toCharArray();
		try {
			for (int kk = 0; (kk < tempChar.length && toCount > reInt); kk++) {
				String s1 = String.valueOf(tempChar[kk]);
				byte[] b;
				b = s1.getBytes("GBK");
				reInt += b.length;
				reStr += tempChar[kk];
			}
		} catch (UnsupportedEncodingException e) {
		}
		if (toCount == reInt || (toCount == reInt - 1))
			reStr += more;
		return reStr;
	}

	/**
	 * 返回数组,移除delElement对象
	 * 
	 * @param source
	 *            原数组
	 * @param delElement
	 *            要删除的元素
	 * @return String[] 编辑之后的数组
	 */
	public static String[] toArray(String[] source, String delElement) {
		if (source == null || delElement == null)
			return null;
		List<String> tempList = new ArrayList<String>();
		for (int i = 0; i < source.length; i++) {
			if (!delElement.equals(source[i])) {
				tempList.add(source[i]);
			}
		}
		return (String[]) tempList.toArray(new String[tempList.size()]);
	}

	/**
	 * 将array分隔成二个String[]放在map中 get["array1"] get["array2"]获取
	 * 
	 * @param array
	 *            数据列表
	 * @param delim
	 *            分割符
	 * @return Map 结果
	 */
	public static Map<String, String[]> getMap(String[] array, String delim) {
		if (array == null || array.length == 0)
			return null;
		Map<String, String[]> map = new HashMap<String, String[]>();
		String[] aaa = new String[array.length];
		String[] bbb = new String[array.length];
		for (int i = 0; i < array.length; i++) {
			String[] temp = split(array[i], ",");
			aaa[i] = temp[0];
			bbb[i] = temp[1];
		}
		map.put("array1", aaa);
		map.put("array2", bbb);
		return map;
	}

	/**
	 * 导出时,把整个电话号码输出显示,请确认输入字符串正确 将电话号码格式从 # # # 返回"" #86#0571#777777777#777# 转化
	 * 086-0571-777777777-777 或 #86#0571#777777777# 转化 086-0571-777777777 或
	 * #086# # # # 使用 formatPhone("#086#0571#777777777#777#", "#","-");
	 * 
	 * @param phone
	 * @param pridelim
	 *            前先的分隔符
	 * @param delim
	 *            格式化以后的分隔符
	 * @return String 格式化以后的数据
	 */
	public static String formatPhone(String phone, String pridelim, String delim) {

		if (phone == null || pridelim == null || delim == null)
			return "";
		phone = phone.replaceFirst(pridelim, "");
		StringBuffer buffer = new StringBuffer();
		String[] temp = phone.split(pridelim);
		if (temp == null)
			return phone;
		if (temp.length > 0) {
			for (int i = 0; i < temp.length; i++) {
				if (!" ".equals(temp[i]) && temp[i] != "") {
					buffer.append(temp[i] + "-");
				}
			}
			String result = buffer.toString();
			if (result.length() > 0)
				return result.substring(0, result.length() - 1);
			else
				return "";
		}
		return phone;
	}

	/**
	 * 返回过滤后的map
	 * 
	 * @param source
	 *            一定比array中数据要少,是选中的数据
	 * @param array
	 *            格式"1;2"其中1在source中存在的话,则添加map.put("1","2");
	 * @return 返回数组中有的数据的Map
	 */
	public static Map<String, String> getArrayCommonMap(String[] source, String[] array) {
		Map<String, String> map = new HashMap<String, String>();
		if (source != null || array != null) {
			if (array.length > 0) {
				for (int i = 0; i < source.length; i++) {
					map.put(source[i], source[i]);
				}
				for (int i = 0; i < array.length; i++) {
					String[] element = array[i].split(";");
					if (map.containsKey(element[0]))
						map.put(element[0], element[1]);
					else
						map.remove(element[0]);
				}
			}
		}
		return map;
	}

	/**
	 * 返回字符串中的值为map
	 * 
	 * @param str
	 *            字符串 "12,16,19,42"
	 * @param delim
	 *            ","
	 * @return Map map格式的数据
	 */
	public static Map<String, String> getSelectIdsMap(String str, String delim) {
		Map<String, String> map = new HashMap<String, String>();
		if (str != null || "".equals(str)) {
			StringTokenizer t = new StringTokenizer(str, delim, true);
			while (t.hasMoreTokens()) {
				String s = t.nextToken(delim);
				map.put(s, s);
			}
		}
		return map;
	}

	/**
	 * 将Java的换行符转换成HTML的换行符
	 * 
	 * @param str
	 *            数据
	 * @return String 转化后的数据
	 */
	public static String replaceHtmlBR(String str) {
		return str.replaceAll("\n", "<BR>");
	}

	/**
	 * 首字母大写。
	 * 
	 * @param words
	 *            数据
	 * @return String 转化后的数据
	 */
	public static String upperFirstChar(String words) {
		return Character.toUpperCase(words.toCharArray()[0]) + words.substring(1, words.length());
	}

	/**
	 * 字符串是否在数组中。
	 * 
	 * @param word
	 *            要查找的数据
	 * @param words
	 *            数组
	 * @return boolean 是否在数组中
	 */
	public static boolean isInArray(String word, String[] words) {
		for (int i = 0; i < words.length; i++) {
			if (word.equals(words[i])) {
				return true;
			}
		}
		return false;
	}

	/**
	 * 解决中文的乱码问题
	 * 
	 * @param chi
	 *            为输入的要汉化的字符串 @return 经过转换后的字符串
	 * @return String 转码之后的数据
	 */
	public static String trans(String chi) {

		if (StringUtil.isEmpty(chi))
			return "";

		String result = null;
		byte temp[];
		try {
			temp = chi.getBytes("ISO-8859-1");
			result = new String(temp, "GBK");

		} catch (UnsupportedEncodingException e) {
			// TODO Auto-generated catch block
			// e.printStackTrace();
		}
		return result;

	}

	/**
	 * 8859转UTF-8
	 * 
	 * @param chi
	 *            原数据
	 * @return String 转码后的数据
	 */
	public static String trans8859ToUTF8(String chi) {

		if (StringUtil.isEmpty(chi))
			return "";

		String result = null;
		byte temp[];
		try {
			temp = chi.getBytes("ISO-8859-1");
			result = new String(temp, "UTF-8");
		} catch (UnsupportedEncodingException e) {
			// TODO Auto-generated catch block
			// e.printStackTrace();
		}

		return result;

	}

	/**
	 * UTF-8转8859
	 * 
	 * @param chi
	 *            原数据
	 * @return String 转码后的数据
	 */
	public static String transUTF8To8859(String chi) {

		if (StringUtil.isEmpty(chi))
			return "";

		String result = null;
		byte temp[];
		try {
			temp = chi.getBytes("UTF-8");
			result = new String(temp, "ISO-8859-1");
		} catch (UnsupportedEncodingException e) {
			// TODO Auto-generated catch block
			// e.printStackTrace();
		}

		return result;

	}

	/**
	 * UTF-8转GBK
	 * 
	 * @param chi
	 *            原数据
	 * @return String 转码后的数据
	 */
	public static String transUtf8ToChi(String chi) {

		if (StringUtil.isEmpty(chi))
			return "";

		String result = null;
		byte temp[];
		try {
			temp = chi.getBytes("UTF-8");
			result = new String(temp, "GBK");
		} catch (UnsupportedEncodingException e) {
			// TODO Auto-generated catch block
			// e.printStackTrace();
		}

		return result;

	}

	/**
	 * GBK转UTF-8
	 * 
	 * @param chi
	 *            原数据
	 * @return String 转码后的数据
	 */
	public static String transChiToUtf8(String chi) {

		if (StringUtil.isEmpty(chi))
			return "";

		String result = null;
		byte temp[];
		try {
			temp = chi.getBytes("GBK");
			result = new String(temp, "UTF-8");
		} catch (UnsupportedEncodingException e) {
			// TODO Auto-generated catch block
			// e.printStackTrace();
		}

		return result;

	}

	/**
	 * GBK转8859
	 * 
	 * @param chi
	 *            原数据
	 * @return String 转码后的数据
	 */
	public static String transChiTo8859(String chi) {

		if (StringUtil.isEmpty(chi))
			return "";

		String result = null;
		byte temp[];
		try {
			temp = chi.getBytes("GBK");
			result = new String(temp, "ISO-8859-1");
		} catch (UnsupportedEncodingException e) {
			// TODO Auto-generated catch block
			// e.printStackTrace();
		}

		return result;

	}

	/**
	 * 描述：根据传入的网址读取该网页的内容
	 * 
	 * @param url
	 *            网址
	 * @return String 网页的内容
	 */
	public static String readByURL(String url) {

		StringBuffer sb = new StringBuffer();

		try {

			String sCurrentLine = "";

			java.io.InputStream l_urlStream;

			java.net.URL l_url = new java.net.URL(url);

			java.net.HttpURLConnection l_connection = (java.net.HttpURLConnection) l_url.openConnection();

			l_connection.connect();

			l_urlStream = l_connection.getInputStream();

			InputStreamReader inputStreamReader = new java.io.InputStreamReader(l_urlStream);

			java.io.BufferedReader l_reader = new java.io.BufferedReader(new java.io.InputStreamReader(l_urlStream));

			while ((sCurrentLine = l_reader.readLine()) != null) {
				sb.append(sCurrentLine);
			}

		} catch (Exception e) {
			e.printStackTrace();
		}

		return sb.toString();

	}

	/**
	 * 如果指定的数据为空,则返回"未知"
	 * 
	 * @param value
	 *            数据
	 * @return String 指定的数据为空,则返回"未知"
	 */
	public static String changeNullToUnkown(String value) {
		if (StringUtil.isEmpty(value)) {
			return "未知";
		} else {
			return value;
		}
	}

	/**
	 * 把数据的前缀去掉
	 * 
	 * @param totalName
	 *            全数值
	 * @param prefix
	 *            前缀
	 * @return String 去掉了前缀的数值
	 */
	public static String minus(String totalName, String prefix) {
		if (StringUtil.isEmpty(totalName) || StringUtil.isEmpty(prefix)) {
			return totalName;
		}
		if (totalName.startsWith(prefix)) {
			return totalName.substring(prefix.length() - 1);
		} else {
			return totalName;
		}
	}

	/**
	 * 按照字节数校验
	 * 
	 * @param str
	 *            文字长度
	 * @param maxLen
	 *            最大长度
	 * @return boolean 是否超出长度
	 */
	public static boolean byteLengthCheck(String str, int maxLen) {
		if (str == null || maxLen < 0) {
			return true;
		}

		byte[] strByte;
		try {
			strByte = str.getBytes("GBK");
			if (strByte.length > maxLen) {
				return false;
			} else {
				return true;
			}
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return false;
	}

	/**
	 * 截取字符串的后n的字节
	 * 
	 * @param str
	 *            字符串
	 * @param len
	 *            长度
	 * @return String 输出字符串
	 */
	public static String beforeSubString(String str, int len) {
		if (str == null || len <= 0) {
			return "";
		}
		byte[] strByte = str.getBytes();

		int strLen = strByte.length;

		if (strLen <= len) {
			return str;
		}

		int count = 0;
		int i;
		for (i = 0; count < len; i++) {
			String ch = str.substring(i, i + 1);
			count += ch.getBytes().length;
		}
		if (count > len) {
			i -= 1;
		}
		return str.substring(0, i);

	}

	/**
	 * 判断一个List里面是否有指定的对象
	 * 
	 * @param dataList
	 *            数据列表
	 * @param data
	 *            目标数据
	 * @return boolean 如果在里面的话，则返回true;否则返回false
	 */
	public static boolean contain(List<String> dataList, String data) {
		if (dataList == null) {
			return false;
		}
		return dataList.contains(data);
	}

	/**
	 * 如果指定的字符串的长度小于指定的长度的话，在字符串的前面用指定的 字符填充
	 * 
	 * @param strData
	 *            字符串
	 * @param cha
	 *            字符
	 * @param length
	 *            长度
	 * @return String 补足长度之后的字符串
	 */
	public static String format(String strData, char cha, int length) {
		StringBuffer newData = new StringBuffer();
		if (length <= 0) {
			return strData;
		}
		strData = StringUtil.notNull(strData);
		int oldLength = strData.length();
		if (oldLength >= length) {
			return strData;
		}

		for (int i = oldLength; i < length; i++) {
			newData.append(cha);
		}
		newData.append(strData);
		return newData.toString();
	}

	/**
	 * 如果指定的字符串的长度小于指定的长度的话，在字符串的前面用指定的 字符填充
	 * 
	 * @param strData
	 *            字符串
	 * @param cha
	 *            字符
	 * @param length
	 *            长度
	 * @return String 补足长度之后的字符串
	 */
	public static String formatWithZero(String strData, int length) {
		return format(strData, '0', length);
	}

	/**
	 * 把一个数据中的html字符转换成html转义符 该函数是用来做textarea字段的数值显示
	 * 
	 * @param value
	 *            要转义的数据
	 * @return String 转义后的数据
	 */
	public static String toTextareaStr(String value) {

		if (value == null) {
			return ("");
		}

		char content[] = new char[value.length()];
		value.getChars(0, value.length(), content, 0);
		StringBuffer result = new StringBuffer(content.length + 50);

		for (int i = 0; i < content.length; i++) {
			switch (content[i]) {
			case '<':
				result.append("&lt;");
				break;
			case '>':
				result.append("&gt;");
				break;
			case '&':
				result.append("&amp;");
				break;
			case '"':
				result.append("&quot;");
				break;
			case '\'':
				result.append("&#39;");
				break;
			default:
				result.append(content[i]);
			}
		}

		String temp = replace(result.toString(), "\r\n", "<br>");
		temp = replace(result.toString(), "\n", "<br>");
		return temp;
	}

	/**
	 * 按照字节数校验
	 * 
	 * @param str
	 *            文字长度
	 * @param maxLen
	 *            最大长度
	 * @param charset
	 *            字符集
	 * @return boolean 是否超出长度
	 */
	public static boolean byteLengthCheck(String str, int maxLen, String charset) {
		if (str == null || maxLen < 0) {
			return true;
		}

		byte[] strByte;
		try {
			strByte = str.getBytes(charset);
			if (strByte.length > maxLen) {
				return false;
			} else {
				return true;
			}
		} catch (UnsupportedEncodingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return false;
	}

	/**
	 * 把code的值转换成路径 先把code取得hashCode码,再进行转化。
	 * 
	 * @param code
	 *            String 要转换的code
	 * @return 表示路径的字符串
	 */
	public static String idToHashPath(String code) {
		return idToPath(Math.abs(code.hashCode()));
	}

	/**
	 * 把code的值转换成路径 先把code取得hashCode码,再进行转化。
	 * 
	 * @param code
	 *            String 要转换的code
	 * @return 表示路径的字符串
	 */
	public static String addUrlParam(String url, String paramName, String paramValue) {
		StringBuffer resultUrl = new StringBuffer();
		url = StringUtil.notNull(url).trim();
		if (url.length() == 0) {
			return "";
		}
		resultUrl.append(url);
		int index = url.indexOf("?");
		int lastIndex = url.lastIndexOf("?");
		// url中有？
		if (index >= 0) {
			// url是以？结尾
			if (url.endsWith("?")) {
				// 只有一个？
				if (index == lastIndex) {
					resultUrl.append(paramName).append("=").append(paramValue);
				} else {
					// 有多个？的情况下
					resultUrl.append("&").append(paramName).append("=").append(paramValue);
				}
			} else {
				// 不是以？结尾
				resultUrl.append("&").append(paramName).append("=").append(paramValue);
			}
		} else {
			resultUrl.append("?").append(paramName).append("=").append(paramValue);
		}
		return resultUrl.toString();
	}

	/**
	 * 取得指定对象，指定方法的返回值
	 * 
	 * @param obj
	 *            对象
	 * @param methodName
	 *            方法名称
	 * @return String 结果
	 */
	public static String invokeMethod(Object obj, String methodName) {
		Method method;
		Object result = null;
		if (obj == null) {
			return "";
		}
		try {
			method = obj.getClass().getMethod(methodName, new Class[0]);
			result = method.invoke(obj);
		} catch (NoSuchMethodException e) {
		} catch (IllegalArgumentException e) {
		} catch (IllegalAccessException e) {
		} catch (InvocationTargetException e) {
		}
		if (result == null) {
			return "";
		} else {
			return result.toString();
		}
	}

	/**
	 * 按字节截取字符串,中文当两个字节。
	 * 
	 * @param str
	 *            字符串
	 * @param len
	 *            截取长度
	 * @return String 截取的字符串
	 * @throws UnsupportedEncodingException
	 */
	public static String subStrByByte(String str, int len) throws UnsupportedEncodingException {
		if (StringUtil.isEmpty(str)) {
			return str;
		}
		byte[] b = str.getBytes("GBK");
		if (b.length <= len) {
			return str;
		}
		int count = 0;
		String sub = "";
		for (int i = 0; i < b.length; i++) {
			if (b[i] < 0) {
				count++;
			}
			if (i >= len) {
				sub = str.substring(0, len - count / 2);
				break;
			}
		}
		return sub;
	}

	/**
	 * 取得文件的http相对路径
	 * 
	 * @param fileId
	 *            文件ID
	 * @param fileName
	 *            文件名称
	 * @return 成功返回文件的http相对路径, 否则返回""
	 */
	public static String getHttpPath(Long fileId, String fileName) {
		if (fileId == null) {
			return "";
		}
		String strFileId = String.valueOf(fileId);
		strFileId = StringUtil.formatWithZero(strFileId, 10);
		String filePath = "";
		filePath = filePath + strFileId.substring(0, 2) + "/";
		filePath = filePath + strFileId.substring(2, 4) + "/";
		filePath = filePath + strFileId.substring(4, 6) + "/";
		filePath = filePath + strFileId.substring(6, 8) + "/" + fileName;
		return filePath;
	}

	/**
	 * 根据文件的ID生成文件的相对路径
	 * 
	 * @param fileId
	 * @return
	 */
	public static String createOnlinePath(Long fileId) {
		if (fileId == null) {
			return "";
		}
		String strFileId = String.valueOf(fileId);
		strFileId = StringUtil.formatWithZero(strFileId, 10);
		String filePath = "";
		filePath = filePath + strFileId.substring(0, 4) + "/";
		filePath = filePath + strFileId.substring(4, 6) + "/";
		filePath = filePath + strFileId.substring(6, 8) + "/";
		filePath = filePath + strFileId.substring(8, 10) + "/";
		return filePath;
	}

	/**
	 * encodeurl，使用GBK编码
	 * 
	 * @param name
	 *            要编码的字符
	 * @return String 编码后的字符
	 */
	public static String encodeUrlByGbk(String name) {
		if (name == null) {
			return "";
		}
		try {
			name = java.net.URLEncoder.encode(name, "GBK");
		} catch (Exception e) {
		}
		return name;
	}

	public static void main(String[] args) {
		// System.out.println(StringUtil.substring("峩，鈀訫丟ㄋ",10,"..."));
		// //System.out.println(StringUtil.substrWithByte("123456你",7));
		// StringUtil.substrWithByte("峩，鈀訫丟ㄋ",10);
		// StringUtil.substrWithByte("1我456你1",7);
		// testGetmailInfo("06黄鸿庆0631003710杭州市文三");
		// testGetmailInfo("08黄鸿庆黄053100314杭州市文三路阿");
		// testGetmailInfo("00053100314杭州市文三路阿");
		// testGetmailInfo("08黄鸿庆黄0014杭州市文三路阿里巴巴爸爸");
		// testGetmailInfo("08黄鸿庆黄053100300");
		//
		// testGetmailInfo("");
		// testGetmailInfo(null);
		// testGetmailInfo("`a`b`c`d`");
		// testGetmailInfo("`a`b`c`d`");
		// testGetmailInfo("`asdf`as`sd`sd`");

		// System.out.println(StringUtil.addUrlParam("http://www.alibaba.com?a.jsp",
		// "needLogin", "true"));
		// System.out.println(StringUtil.addUrlParam("http://www.alibaba.com?",
		// "needLogin", "true"));
		// System.out.println(StringUtil.addUrlParam("http://www.alibaba.com&",
		// "needLogin", "true"));
		// System.out.println(StringUtil.addUrlParam("http://www.alibaba.com/a.jsp?abc?",
		// "needLogin", "true"));
		// System.out.println(StringUtil.getHour(24));
		// System.out.println(StringUtil.getHour(0));
		/*
		 * Date date = new Date(); String filePath =
		 * "C:\\Documents and Settings\\haijie.shihj\\桌面\\工作记录\\灰度发布项目\\复件 mulid.txt"
		 * ;//文件路径 BufferedReader reader = null; String[] uidArray = new
		 * String[1000]; Map map = new HashMap(); map.put("cntaobao", "");
		 * map.put("cnwujing", ""); map.put("glbfoods", ""); map.put("chnaigou",
		 * ""); map.put("cntbbtoc", ""); map.put("enaliint", "");
		 * map.put("wangwang", ""); map.put("cnkoubei", ""); map.put("cnanonym",
		 * ""); map.put("cnalimam", ""); map.put("chnyahoo", "");
		 * map.put("htyahooo", ""); map.put("cnalichn", ""); int count = 0; try{
		 * reader= new BufferedReader(new InputStreamReader(new
		 * FileInputStream(new File(filePath)))); try { String line = null; int
		 * current_size = 0; while((line = reader.readLine())!=null){ count++;
		 * line = line.trim();//去前后空格
		 * if(line.length()>WebimConstant.MAX_LENGTH_LOGIN_ID
		 * ||line.length()<=WebimConstant.SITE_LENGTH)//剔除长度不符合的部分 continue;
		 * if(!map.containsKey(line.substring(0,
		 * WebimConstant.SITE_LENGTH))){//剔除站点前缀不符合的部分 continue; }
		 * if(current_size<1000){ uidArray[current_size++] = line; }else{
		 * System.out.println(line); current_size = 0; uidArray[current_size++]
		 * = line; } } System.out.println(current_size); } catch (IOException e)
		 * { System.out.println(" file read exception"); } finally{ try {
		 * reader.close(); } catch (IOException e) {
		 * System.out.println(" file close exception"); } }
		 * }catch(FileNotFoundException e){
		 * System.out.println("file not exist"); }finally{//当线程结束时修改用户组状态
		 * System.out.println(count+":"+(new Date().getTime()-date.getTime()));
		 * }
		 */
		// String a = null;
		// System.out.println(a==null||a instanceof String);
		// try {
		// File file = new File("");
		// System.out.print(System.getProperty("file.encoding"));
		// } catch (Exception e) {
		// // TODO Auto-generated catch block
		// e.printStackTrace();
		// }

		System.out.println(StringUtil.toLowerCaseWithUnderscores("avgCPC"));
	}

	public static String fenToYuan(Long yuan) {
		return new Double(yuan / 100.0).toString();
	}

	/**
	 * 判断字符串是否超过一定的长度 超过num长返回 true，否则 false
	 * 
	 * @param str
	 * @param num
	 * @return boolean
	 * @author 方修龙 2008-07-04
	 */
	public static boolean isExceedLength(String str, int num) {
		// 如果传入的字符串不为空,则返回字符串长度
		if (str != null && !("").equals(str)) {
			// 如果str的长度超过了num,则返回true,否则返回false
			if (str.length() > num)
				return true;
			else
				return false;
			// 如果传入的字符为空,则返回false
		} else {
			return false;
		}
	}

	/**
	 * 将一个整数类型的数字转换成IP地址
	 * 
	 * @param num
	 * @return String
	 * @author 方修龙 2008-07-21
	 */
	public static String Dot2StringIP(long Ip_Num) {
		long changNum = (long) Math.pow(2, 32);
		if (Ip_Num < 0) {
			Ip_Num = Ip_Num + changNum;
		}
		String ip = "";
		long tmp;
		//
		// tmp = Ip_Num / 16777216;
		// ip += tmp + ".";
		// Ip_Num = Ip_Num - tmp * 16777216;
		//
		// tmp = Ip_Num / 65536;
		// ip += tmp + ".";
		// Ip_Num = Ip_Num - tmp * 65536;
		//
		// tmp = Ip_Num / 256;
		// ip += tmp + ".";
		// Ip_Num = Ip_Num - tmp * 256;
		//
		// ip += Ip_Num;

		tmp = Ip_Num / 16777216;
		ip += tmp;
		Ip_Num = Ip_Num - tmp * 16777216;

		tmp = Ip_Num / 65536;
		ip = tmp + "." + ip;
		Ip_Num = Ip_Num - tmp * 65536;

		tmp = Ip_Num / 256;
		ip = tmp + "." + ip;
		Ip_Num = Ip_Num - tmp * 256;

		ip = Ip_Num + "." + ip;
		return ip;
	}

	/**
	 * 将127.0.0.1形式的IP地址转换成十进制整数，这里没有进行任何错误处理
	 * 
	 * @param strIp
	 * @return long ip
	 * @author 方修龙 2008-09-05
	 */
	public static long ipToLong(String strIp) {
		if (isEmpty(strIp)) {
			return 0;
		}
		long[] ip = new long[4];
		// 先找到IP地址字符串中.的位置
		int position1 = strIp.indexOf(".");
		int position2 = strIp.indexOf(".", position1 + 1);
		int position3 = strIp.indexOf(".", position2 + 1);
		// 将每个.之间的字符串转换成整型
		ip[0] = Long.parseLong(strIp.substring(0, position1));
		ip[1] = Long.parseLong(strIp.substring(position1 + 1, position2));
		ip[2] = Long.parseLong(strIp.substring(position2 + 1, position3));
		ip[3] = Long.parseLong(strIp.substring(position3 + 1));
		long num = 0;
		num = num + (ip[0] << 24);
		num = num + (ip[1] << 16);
		num = num + (ip[2] << 8);
		num = num + ip[3];
		return num;
	}

	// public static void main(String[] args){
	// Date nowDate = new Date();
	// System.out.println("nowDate=="+nowDate);
	// int second = nowDate.getSeconds();
	// int after5Second = second + 5;
	// nowDate.setSeconds(after5Second);
	// System.out.println("nowDate22=="+nowDate);
	// System.out.println("after5Second=="+after5Second);
	// }

	/**
	 * 例如：10.2.226.6 010002226006
	 * 
	 * @param ip
	 * @return String 如果传入参数IP为空,则返回""，如果不为null,则返回格式化后的IP
	 */
	public static String formatIp(String ip) {
		StringBuffer sb = new StringBuffer();
		if (isEmpty(ip)) {
			return "";
		} else {
			String[] ipArr = split(ip, ".");
			for (int i = 0; i < ipArr.length; i++) {
				sb.append(formatWithZero(ipArr[i], 3));
			}
		}
		return sb.toString();
	}

	/**
	 * 字符串类型的时间进行比较 strDate1 格式 如：2008-09-22 12:24:23
	 * 
	 * @param strDate1
	 * @param strDate2
	 * @return 当strDate1 < strDate2时 -1 当strDate1 = strDate2时 0 当strDate1 >
	 *         strDate2时 1
	 */
	public static int strDateCompare(String strDate1, String strDate2) {
		if (strDate1.compareTo(strDate2) > 0) {
			return 1;
		} else if (strDate1.compareTo(strDate2) == 0) {
			return 0;
		} else if (strDate1.compareTo(strDate2) < 0) {
			return -1;
		}
		return 0;
	}

	/**
	 * 取字符串的长度
	 * 
	 * @param str
	 * @return int length
	 * @author 方修龙
	 */
	public static int getStrByteLength(String str) {
		if (isEmpty(str)) {
			return 0;
		}
		int length = 0;
		try {
			length = str.getBytes("GBK").length;
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return length;
	}

	/**
	 * 把list对象转化成为数组对象
	 * 
	 * @param dataList
	 *            list对象
	 * @return String[] 数组对象
	 */
	public static String[] listToArray(List<String> dataList) {
		if (dataList == null || dataList.size() == 0) {
			return null;
		}
		String[] ret = new String[dataList.size()];
		for (int i = 0; i < dataList.size(); i++) {
			ret[i] = dataList.get(i);
		}
		return ret;
	}

	/**
	 * 取得数组的长度
	 * 
	 * @param data
	 *            数组
	 * @return int 数组的长度
	 */
	public static int length(String[] data) {
		if (data == null) {
			return 0;
		}
		return data.length;
	}

	/**
	 * 取得附件后缀名称
	 * 
	 * @param fileName
	 *            文件名称
	 * @return String 后缀名称
	 */
	public static String getSuffixName(String fileName) {
		if (StringUtil.isEmpty(fileName) || fileName.lastIndexOf(".") < 0) {
			return "";
		}
		String suffixName = fileName.substring(fileName.lastIndexOf("."));
		return suffixName.toLowerCase().trim();
	}

	public static String decodeURLByGbk(String name) {
		if (name == null) {
			return "";
		}
		try {
			name = java.net.URLDecoder.decode(name, "GBK");
		} catch (Exception e) {
		}
		return name;
	}

	/**
	 * 将String中的所有pattern匹配的字串替换掉
	 * 
	 * @param sequence
	 *            代替换的字符串
	 * @param regex
	 *            替换查找的正则表达式对象
	 * @param replacement
	 *            替换函数
	 * @return 替换后的新字符串
	 */
	public static String replace(CharSequence sequence, String regex, IReplaceCallback replacement) {
		if (sequence == null)
			return null;
		Matcher m = Pattern.compile(regex).matcher(sequence.toString());
		if (m.find()) {
			StringBuffer sb = new StringBuffer();
			int index = 0;
			while (true) {
				m.appendReplacement(sb, Matcher.quoteReplacement(replacement.replace(m.group(0), index++, m)));
				if (m.find())
					continue;
				else
					break;
			}
			m.appendTail(sb);
			return sb.toString();
		}
		return sequence.toString();
	}

	/**
	 * 将String中的regex第一次匹配的字串替换掉
	 * 
	 * @param string
	 *            代替换的字符串
	 * @param regex
	 *            替换查找的正则表达式
	 * @param replacement
	 *            替换函数
	 * @return 替换后的新字符串
	 */
	public static String replaceFirst(String string, String regex, IReplaceCallback replacement) {
		if (string == null)
			return null;
		Matcher m = Pattern.compile(regex).matcher(string);
		StringBuffer sb = new StringBuffer();
		if (m.find()) {
			m.appendReplacement(sb, Matcher.quoteReplacement(replacement.replace(m.group(0), 0, m)));
		}
		m.appendTail(sb);
		return sb.toString();
	}

	/**
	 * 字符串替换的回调接口
	 */
	public interface IReplaceCallback {
		/**
		 * 将text转化为特定的字串返回
		 * 
		 * @param text
		 *            指定的字符串
		 * @param index
		 *            替换的次序
		 * @param matcher
		 *            Matcher对象
		 * @return
		 */
		public String replace(String text, int index, Matcher matcher);
	}

	/**
	 * 抽象的字符串替换接口
	 * <p>
	 * 主要是添加了$(group)方法来替代matcher.group(group)
	 */
	public static abstract class ReplaceCallback implements IReplaceCallback {
		protected Matcher matcher;

		public abstract String replace(String text, int index);

		/**
		 * 将text转化为特定的字串返回
		 * 
		 * @param text
		 *            指定的字符串
		 * @param index
		 *            替换的次序
		 * @param matcher
		 *            Matcher对象
		 * @return 替换后的新字符串
		 */
		public final String replace(String text, int index, Matcher matcher) {
			this.matcher = matcher;
			try {
				return replace(text, index);
			} finally {
				this.matcher = null;
			}
		}

		/**
		 * 获得matcher中的组数据
		 * <p>
		 * 等同于matcher.group(group)
		 * <p>
		 * 该函数只能在{@link #replace(String, int)} 中调用
		 * 
		 * @param group
		 *            组
		 * @return 组数据
		 */
		protected final String $(int group) {
			String data = matcher.group(group);
			return data == null ? "" : data;
		}
	}

	/**
	 * 将字符串转换成下划线分隔的小写字符串。
	 * <p>
	 * 如果字符串是<code>null</code>则返回<code>null</code>。
	 * 
	 * <pre>
	 * StringUtil.toLowerCaseWithUnderscores(null)  = null
	 * StringUtil.toLowerCaseWithUnderscores("")    = ""
	 * StringUtil.toLowerCaseWithUnderscores("aBc") = "a_bc"
	 * StringUtil.toLowerCaseWithUnderscores("aBc def") = "a_bc_def"
	 * StringUtil.toLowerCaseWithUnderscores("aBc def_ghi") = "a_bc_def_ghi"
	 * StringUtil.toLowerCaseWithUnderscores("aBc def_ghi 123") = "a_bc_def_ghi_123"
	 * StringUtil.toLowerCaseWithUnderscores("__a__Bc__") = "__a__bc__"
	 * </pre>
	 * 
	 * </p>
	 * <p>
	 * 此方法会保留除了空白以外的所有分隔符。
	 * </p>
	 * 
	 * @param str
	 *            要转换的字符串
	 * @return 下划线分隔的小写字符串，如果原字符串为<code>null</code>，则返回<code>null</code>
	 */
	public static String toLowerCaseWithUnderscores(String str) {
		return new WordTokenizer() {
			@Override
			protected void startSentence(StringBuilder buffer, char ch) {
				buffer.append(Character.toLowerCase(ch));
			}

			@Override
			protected void startWord(StringBuilder buffer, char ch) {
				if (!isDelimiter(buffer.charAt(buffer.length() - 1))) {
					buffer.append(UNDERSCORE);
				}

				buffer.append(Character.toLowerCase(ch));
			}

			@Override
			protected void inWord(StringBuilder buffer, char ch) {
				buffer.append(Character.toLowerCase(ch));
			}

			@Override
			protected void startDigitSentence(StringBuilder buffer, char ch) {
				buffer.append(ch);
			}

			@Override
			protected void startDigitWord(StringBuilder buffer, char ch) {
				if (!isDelimiter(buffer.charAt(buffer.length() - 1))) {
					buffer.append(UNDERSCORE);
				}

				buffer.append(ch);
			}

			@Override
			protected void inDigitWord(StringBuilder buffer, char ch) {
				buffer.append(ch);
			}

			@Override
			protected void inDelimiter(StringBuilder buffer, char ch) {
				buffer.append(ch);
			}
		}.parse(str);
	}

	/**
	 * 通过源字符串重复生成N次组成新的字符串
	 * @param str 源字符串 例如: 空格(" "), 星号("*")等
	 * @param num 重复生成次数
	 * @return
	 */
	public static String repeat(String str,Integer num){
		StringBuffer s = new StringBuffer();
		 for (int i = 0; i < num; i++){
			 s.append(str);
		 }
		 return s.toString();
	}
	/**
	 * 去除str两边字符ch
	 * @param str
	 * @param ch
	 * @return
	 */
	public static String trimChar(String str,char ch){
		String result = str;
		if(str != null){
			char[] value = str.toCharArray();
			int len = value.length;
	        int st = 0;
	        char[] val = value;

	        while ((st < len) && (val[st] == ch)) {
	            st++;
	        }
	        while ((st < len) && (val[len - 1] == ch)) {
	            len--;
	        }
	        if((st > 0) || (len < value.length)){
	        	result = str.substring(st, len);
	        }
		}
		return result;
	}
	
	/**
	 * 从字符串index=0位置开始截取长度为n的字符串
	 * @param str
	 * @param n
	 * @author tangqin
	 * @date 2014-01-11
	 */
	public static String substr(String str,Integer n){
		if(str != null && n != null && n > 0){
			int len = str.length();
			if(n>=len){
				return str;
			}else{
				return str.substring(0,n);
			}
		}else{
			return "";
		}
	}
	
	/**
	 * 解析出下列语法所构成的<code>SENTENCE</code>。
	 * 
	 * <pre>
	 *  SENTENCE = WORD (DELIMITER* WORD)*
	 * 
	 *  WORD = UPPER_CASE_WORD | LOWER_CASE_WORD | TITLE_CASE_WORD | DIGIT_WORD
	 * 
	 *  UPPER_CASE_WORD = UPPER_CASE_LETTER+
	 *  LOWER_CASE_WORD = LOWER_CASE_LETTER+
	 *  TITLE_CASE_WORD = UPPER_CASE_LETTER LOWER_CASE_LETTER+
	 *  DIGIT_WORD      = DIGIT+
	 * 
	 *  UPPER_CASE_LETTER = Character.isUpperCase()
	 *  LOWER_CASE_LETTER = Character.isLowerCase()
	 *  DIGIT             = Character.isDigit()
	 *  NON_LETTER_DIGIT  = !Character.isUpperCase() && !Character.isLowerCase() && !Character.isDigit()
	 * 
	 *  DELIMITER = WHITESPACE | NON_LETTER_DIGIT
	 * </pre>
	 */
	private abstract static class WordTokenizer {
		protected static final char UNDERSCORE = '_';

		/**
		 * Parse sentence。
		 */
		public String parse(String str) {
			if (StringUtil.isEmpty(str)) {
				return str;
			}

			int length = str.length();
			StringBuilder buffer = new StringBuilder(length);

			for (int index = 0; index < length; index++) {
				char ch = str.charAt(index);

				// 忽略空白。
				if (Character.isWhitespace(ch)) {
					continue;
				}

				// 大写字母开始：UpperCaseWord或是TitleCaseWord。
				if (Character.isUpperCase(ch)) {
					int wordIndex = index + 1;

					while (wordIndex < length) {
						char wordChar = str.charAt(wordIndex);

						if (Character.isUpperCase(wordChar)) {
							wordIndex++;
						} else if (Character.isLowerCase(wordChar)) {
							wordIndex--;
							break;
						} else {
							break;
						}
					}

					// 1. wordIndex == length，说明最后一个字母为大写，以upperCaseWord处理之。
					// 2. wordIndex == index，说明index处为一个titleCaseWord。
					// 3. wordIndex > index，说明index到wordIndex -
					// 1处全部是大写，以upperCaseWord处理。
					if (wordIndex == length || wordIndex > index) {
						index = parseUpperCaseWord(buffer, str, index, wordIndex);
					} else {
						index = parseTitleCaseWord(buffer, str, index);
					}

					continue;
				}

				// 小写字母开始：LowerCaseWord。
				if (Character.isLowerCase(ch)) {
					index = parseLowerCaseWord(buffer, str, index);
					continue;
				}

				// 数字开始：DigitWord。
				if (Character.isDigit(ch)) {
					index = parseDigitWord(buffer, str, index);
					continue;
				}

				// 非字母数字开始：Delimiter。
				inDelimiter(buffer, ch);
			}

			return buffer.toString();
		}

		private int parseUpperCaseWord(StringBuilder buffer, String str, int index, int length) {
			char ch = str.charAt(index++);

			// 首字母，必然存在且为大写。
			if (buffer.length() == 0) {
				startSentence(buffer, ch);
			} else {
				startWord(buffer, ch);
			}

			// 后续字母，必为小写。
			for (; index < length; index++) {
				ch = str.charAt(index);
				inWord(buffer, ch);
			}

			return index - 1;
		}

		private int parseLowerCaseWord(StringBuilder buffer, String str, int index) {
			char ch = str.charAt(index++);

			// 首字母，必然存在且为小写。
			if (buffer.length() == 0) {
				startSentence(buffer, ch);
			} else {
				startWord(buffer, ch);
			}

			// 后续字母，必为小写。
			int length = str.length();

			for (; index < length; index++) {
				ch = str.charAt(index);

				if (Character.isLowerCase(ch)) {
					inWord(buffer, ch);
				} else {
					break;
				}
			}

			return index - 1;
		}

		private int parseTitleCaseWord(StringBuilder buffer, String str, int index) {
			char ch = str.charAt(index++);

			// 首字母，必然存在且为大写。
			if (buffer.length() == 0) {
				startSentence(buffer, ch);
			} else {
				startWord(buffer, ch);
			}

			// 后续字母，必为小写。
			int length = str.length();

			for (; index < length; index++) {
				ch = str.charAt(index);

				if (Character.isLowerCase(ch)) {
					inWord(buffer, ch);
				} else {
					break;
				}
			}

			return index - 1;
		}

		private int parseDigitWord(StringBuilder buffer, String str, int index) {
			char ch = str.charAt(index++);

			// 首字符，必然存在且为数字。
			if (buffer.length() == 0) {
				startDigitSentence(buffer, ch);
			} else {
				startDigitWord(buffer, ch);
			}

			// 后续字符，必为数字。
			int length = str.length();

			for (; index < length; index++) {
				ch = str.charAt(index);

				if (Character.isDigit(ch)) {
					inDigitWord(buffer, ch);
				} else {
					break;
				}
			}

			return index - 1;
		}

		protected boolean isDelimiter(char ch) {
			return !Character.isUpperCase(ch) && !Character.isLowerCase(ch) && !Character.isDigit(ch);
		}

		protected abstract void startSentence(StringBuilder buffer, char ch);

		protected abstract void startWord(StringBuilder buffer, char ch);

		protected abstract void inWord(StringBuilder buffer, char ch);

		protected abstract void startDigitSentence(StringBuilder buffer, char ch);

		protected abstract void startDigitWord(StringBuilder buffer, char ch);

		protected abstract void inDigitWord(StringBuilder buffer, char ch);

		protected abstract void inDelimiter(StringBuilder buffer, char ch);
		
	}
}